CacheTemporaryMemorizer.java

/*
 * Copyright 2014-2016 CyberVision, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.kaaproject.kaa.server.operations.service.cache.concurrent;

import org.jboss.netty.util.internal.ConcurrentHashMap;
import org.kaaproject.kaa.server.operations.service.cache.Computable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.security.InvalidParameterException;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;


/**
 * The Class CacheTemporaryMemorizer.
 *
 * @param <K> the key type
 * @param <V> the value type
 */
public class CacheTemporaryMemorizer<K, V> {

  /**
   * The Constant LOG.
   */
  private static final Logger LOG = LoggerFactory.getLogger(CacheTemporaryMemorizer.class);

  /**
   * The cache.
   */
  private final ConcurrentMap<K, Future<V>> cache = new ConcurrentHashMap<K, Future<V>>();

  /**
   * If the Throwable is an Error, throw it; if it is a RuntimeException
   * return it, otherwise throw IllegalStateException.
   *
   * @param throwable the t
   * @return the runtime exception
   */
  public static RuntimeException launderThrowable(Throwable throwable) {
    if (throwable instanceof RuntimeException) {
      return (RuntimeException) throwable;
    } else if (throwable instanceof Error) {
      throw (Error) throwable;
    } else {
      throw new IllegalStateException("Cache Operation Exception", throwable);
    }
  }

  /**
   * Compute.
   *
   * @param key    the key
   * @param worker the worker
   * @return the v
   */
  public V compute(final K key, final Computable<K, V> worker) {
    if (key == null) {
      throw new InvalidParameterException("Cache key can't be null");
    }
    while (true) {
      Future<V> future = cache.get(key);
      if (future == null) {
        Callable<V> eval = new Callable<V>() {
          public V call() throws InterruptedException {
            return worker.compute(key);
          }
        };
        FutureTask<V> ft = new FutureTask<V>(eval);
        future = cache.putIfAbsent(key, ft);
        if (future == null) {
          future = ft;
          try {
            ft.run();
            //the idea is not to cache permanently but only for the time of execution.
            //thus, technically, if time of calculation >> time of external
            // cache put -> we will run calculation maximum 2 times.
          } catch (Throwable ex) {
            LOG.error("Exception catched: ", ex);
            throw ex;
          } finally {
            cache.remove(key, ft);
          }
        }
      }
      try {
        return future.get();
      } catch (CancellationException ex) {
        LOG.error("Exception catched: ", ex);
        cache.remove(key, future);
      } catch (ExecutionException | InterruptedException ex) {
        LOG.error("Exception catched: ", ex);
        throw launderThrowable(ex);
      }
    }
  }

  /**
   * Gets the cache size.
   *
   * @return the cache size
   */
  public int getCacheSize() {
    return cache.size();
  }

}